#include "../source/server.hpp"

// TcpServer模块的测试
void OnConnected(const PtrConnection& conn)
{
    DBG_LOG("new connection: %p", conn.get());
}

void OnClosed(const PtrConnection& conn)
{
    DBG_LOG("Closed connection: %p", conn.get());
}

void OnMessage(const PtrConnection& conn, Buffer* buf)
{
    DBG_LOG("%s", buf->ReadPosition());
    buf->MoveReadOffset(buf->ReadAbleSize());
    std::string str = "hello world!";
    conn->Send(str.c_str(), str.size());
    // conn->Shutdown();
}

int main()
{
    TcpServer server(8080);
    server.SetThreadCount(2);
    server.EnableInactivateRelease(10);
    server.SetClosedCallback(OnClosed);
    server.SetConnectedCallback(OnConnected);
    server.SetMessageCallback(OnMessage);
    server.strat();
    return 0;
}





// #include "../source/server.hpp"

// // LoopThreadPool模块的测试
// std::unordered_map<uint64_t, PtrConnection> _conns;
// uint64_t conn_id = 0;
// EventLoop base_loop;
// LoopThreadPool* loop_pool;

// void ConnectionDestory(const PtrConnection& conn)
// {
//     _conns.erase(conn->Id());
// }

// void OnConnected(const PtrConnection& conn)
// {
//     DBG_LOG("new connection: %p", conn.get());
// }

// void OnMessage(const PtrConnection& conn, Buffer* buf)
// {
//     DBG_LOG("%s", buf->ReadPosition());
//     buf->MoveReadOffset(buf->ReadAbleSize());
//     std::string str = "hello world!";
//     DBG_LOG("%s","向客户端发送数据");
//     conn->Send(str.c_str(), str.size());
//     conn->Shutdown();
// }

// void NewConnection(int fd)
// {
//     conn_id++;
//     PtrConnection conn(new Connection(loop_pool->NextLoop(), conn_id, fd));
//     conn->SetMessageCallback(std::bind(OnMessage, std::placeholders::_1, std::placeholders::_2));
//     conn->SetSrvClosedCallback(std::bind(ConnectionDestory, std::placeholders::_1)); 
//     conn->SetConnectedCallback(std::bind(OnConnected, std::placeholders::_1));
//     conn->EnableInactiveRelease(10); // 启动非活跃超时销毁
//     conn->Established(); // 就绪初始化
//     _conns.insert(std::make_pair(conn_id, conn));
//     DBG_LOG("NEW -----------");
// }

// int main()
// {
//     loop_pool = new LoopThreadPool(&base_loop);
//     loop_pool->SetThreadCount(2);
//     loop_pool->Create();

//     Acceptor acceptor(&base_loop, 8080);
//     // 为监听套接字创建一个Channel进行事件的管理,以及事件的管理
//     // 回调中,获取新连接,为新连接创建Channel并且添加监控
//     acceptor.SetAcceptCallback(std::bind(NewConnection, std::placeholders::_1));
//     acceptor.Listen();
//     base_loop.Start();
    
//     return 0;
// }




// // LoopThread模块的测试
// std::unordered_map<uint64_t, PtrConnection> _conns;
// uint64_t conn_id = 0;
// EventLoop base_loop;
// std::vector<LoopThread> threads(2);
// int next_loop = 0;

// void ConnectionDestory(const PtrConnection& conn)
// {
//     _conns.erase(conn->Id());
// }

// void OnConnected(const PtrConnection& conn)
// {
//     DBG_LOG("new connection: %p", conn.get());
// }

// void OnMessage(const PtrConnection& conn, Buffer* buf)
// {
//     DBG_LOG("%s", buf->ReadPosition());
//     buf->MoveReadOffset(buf->ReadAbleSize());
//     std::string str = "hello world!";
//     DBG_LOG("%s","向客户端发送数据");
//     conn->Send(str.c_str(), str.size());
//     conn->Shutdown();
// }

// void NewConnection(int fd)
// {
//     conn_id++;
//     next_loop = (next_loop + 1) % 2;
//     PtrConnection conn(new Connection(threads[next_loop].GetLoop(), conn_id, fd));
//     conn->SetMessageCallback(std::bind(OnMessage, std::placeholders::_1, std::placeholders::_2));
//     conn->SetSrvClosedCallback(std::bind(ConnectionDestory, std::placeholders::_1)); 
//     conn->SetConnectedCallback(std::bind(OnConnected, std::placeholders::_1));
//     conn->EnableInactiveRelease(10); // 启动非活跃超时销毁
//     conn->Established(); // 就绪初始化
//     _conns.insert(std::make_pair(conn_id, conn));
//     DBG_LOG("NEW -----------");
// }

// int main()
// {
//     Acceptor acceptor(&base_loop, 8080);
//     // 为监听套接字创建一个Channel进行事件的管理,以及事件的管理
//     // 回调中,获取新连接,为新连接创建Channel并且添加监控
//     acceptor.SetAcceptCallback(std::bind(NewConnection, std::placeholders::_1));
//     acceptor.Listen();

//     while (1)
//     {
//         base_loop.Start();
//     }
//     return 0;
// }





// // Acceptor模块的测试
// std::unordered_map<uint64_t, PtrConnection> _conns;
// uint64_t conn_id = 0;
// EventLoop loop;

// void ConnectionDestory(const PtrConnection& conn)
// {
//     _conns.erase(conn->Id());
// }

// void OnConnected(const PtrConnection& conn)
// {
//     DBG_LOG("new connection: %p", conn.get());
// }

// void OnMessage(const PtrConnection& conn, Buffer* buf)
// {
//     DBG_LOG("%s", buf->ReadPosition());
//     buf->MoveReadOffset(buf->ReadAbleSize());
//     std::string str = "hello world!";
//     DBG_LOG("%s","向客户端发送数据");
//     conn->Send(str.c_str(), str.size());
//     conn->Shutdown();
// }

// void NewConnection(int fd)
// {
//     conn_id++;
//     PtrConnection conn(new Connection(&loop, conn_id, fd));
//     conn->SetMessageCallback(std::bind(OnMessage, std::placeholders::_1, std::placeholders::_2));
//     conn->SetSrvClosedCallback(std::bind(ConnectionDestory, std::placeholders::_1)); 
//     conn->SetConnectedCallback(std::bind(OnConnected, std::placeholders::_1));
//     conn->EnableInactiveRelease(10); // 启动非活跃超时销毁
//     conn->Established(); // 就绪初始化
//     _conns.insert(std::make_pair(conn_id, conn));
// }

// int main()
// {
//     Acceptor acceptor(&loop, 8080);
//     // 为监听套接字创建一个Channel进行事件的管理,以及事件的管理
//     // 回调中,获取新连接,为新连接创建Channel并且添加监控
//     acceptor.SetAcceptCallback(std::bind(NewConnection, std::placeholders::_1));
//     acceptor.Listen();

//     while (1)
//     {
//         loop.Start();
//     }
//     return 0;
// }




// connection模块的调试
// std::unordered_map<uint64_t, PtrConnection> _conns;
// uint64_t conn_id = 0;

// void ConnectionDestory(const PtrConnection& conn)
// {
//     _conns.erase(conn->Id());
// }

// void OnConnected(const PtrConnection& conn)
// {
//     DBG_LOG("new connection: %p", conn.get());
// }

// void OnMessage(const PtrConnection& conn, Buffer* buf)
// {
//     DBG_LOG("%s", buf->ReadPosition());
//     buf->MoveReadOffset(buf->ReadAbleSize());
//     std::string str = "hello world!";
//     DBG_LOG("%s","向客户端发送数据");
//     conn->Send(str.c_str(), str.size());
//     // conn->Shutdown();
// }

// void Acceptor(EventLoop* loop, Channel* lst_channel)
// {
//     int fd = lst_channel->Fd();
//     int newfd = accept(fd, nullptr, nullptr);
//     if (newfd < 0)
//         return ;
    
//     conn_id++;
//     PtrConnection conn(new Connection(loop, conn_id, newfd));
//     conn->SetMessageCallback(std::bind(OnMessage, std::placeholders::_1, std::placeholders::_2));
//     conn->SetSrvClosedCallback(std::bind(ConnectionDestory, std::placeholders::_1)); 
//     conn->SetConnectedCallback(std::bind(OnConnected, std::placeholders::_1));
//     conn->EnableInactiveRelease(10); // 启动非活跃超时销毁
//     conn->Established(); // 就绪初始化
//     _conns.insert(std::make_pair(conn_id, conn));
// }

// int main()
// {
//     EventLoop loop;
//     Socket lst_sock;
//     lst_sock.CreateServer(8080);
//     // 为监听套接字创建一个Channel进行事件的管理,以及事件的管理
//     Channel channel(&loop, lst_sock.Fd());
//     // 回调中,获取新连接,为新连接创建Channel并且添加监控
//     channel.SetReadCallback(std::bind(Acceptor, &loop, &channel));
//     channel.EnableRead();  // 启动可读事件监控

//     while (1)
//     {
//         loop.Start();
//     }
//     lst_sock.Close();
//     return 0;
// }




// EventLoop模块测试
// #include "../source/server.hpp"


// void HandlerClose(Channel* channel)
// {
//     DBG_LOG("close: %d", channel->Fd());
//     channel->ReMove(); // 移除监控
//     delete channel;
// }

// void HandlerRead(Channel* channel)
// {
//     int fd = channel->Fd();
//     char buf[1024] = {0};
//     int ret = recv(fd, buf, 1023, 0);
//     if (ret <= 0)
//         return HandlerClose(channel);  // 关闭释放
    
//     DBG_LOG("%s", buf);
//     channel->EnableWrite();  // 启动可写事件
// }

// void HandlerWrite(Channel* channel)
// {
//     int fd = channel->Fd();
//     const char* data = "天气还不错!";
//     int ret = send(fd, data, strlen(data), 0);
//     if (ret < 0)
//         return HandlerClose(channel);  // 关闭释放
    
//     channel->DisableWrite();  // 关闭写监控
// }

// void HandlerError(Channel* channel)
// {
//     return HandlerClose(channel);  // 关闭释放
// }

// void HandlerEvent(EventLoop* loop,Channel* channel, uint64_t timerid)
// {
//     loop->TimerRefresh(timerid);
// }


// void Acceptor(EventLoop* loop, Channel* lst_channel)
// {
//     int fd = lst_channel->Fd();
//     int newfd = accept(fd, nullptr, nullptr);
//     if (newfd < 0)
//         return ;
    
//     uint64_t timerid = rand() % 10000;
//     Channel* channel = new Channel(loop, newfd);
//     channel->SetReadCallback(std::bind(HandlerRead, channel));  // 为通信套接字设置可读事件的回调函数
//     channel->SetWriteCallback(std::bind(HandlerWrite, channel)); // 可写事件的回调函数
//     channel->SetCloseCallback(std::bind(HandlerClose, channel));  // 关闭事件的回调函数
//     channel->SetErrorCallback(std::bind(HandlerError, channel));  // 错误事件的回调函数
//     channel->SetEventCallback(std::bind(HandlerEvent, loop, channel, timerid));  // 任意事件的回调函数

//     // 非活跃连接的超时释放操作  --  10s后关闭连接
//     // 注意：定时销毁任务,必须在启动读事件之前, 因为有可能启动了事件监控后,立即就有了事件,但是这时候还没有任务
//     loop->TimerAdd(timerid, 10, std::bind(HandlerClose, channel));
//     channel->EnableRead();
// }

// int main()
// {
//     srand(time(nullptr));
//     EventLoop loop;
//     Socket lst_sock;
//     lst_sock.CreateServer(8080);
//     // 为监听套接字创建一个Channel进行事件的管理,以及事件的管理
//     Channel channel(&loop, lst_sock.Fd());
//     // 回调中,获取新连接,为新连接创建Channel并且添加监控
//     channel.SetReadCallback(std::bind(Acceptor, &loop, &channel));
//     channel.EnableRead();  // 启动可读事件监控

//     while (1)
//     {
//         loop.Start();

//         // std::vector<Channel*> actives;
//         // poller.Poll(&actives);

//         // for (auto& a : actives)
//         //     a->HandleEvent();



//         // int newfd = lst_sock.Accept();
//         // if (newfd < 0)
//         //     continue;
        
//         // Socket cli_sock(newfd);
//         // char buf[1024] = {0};
//         // int ret = cli_sock.Recv(buf, 1023);
//         // if (ret < 0)
//         // {
//         //     cli_sock.Close();
//         //     continue;
//         // }
//         // cli_sock.Send(buf, ret);
//         // cli_sock.Close();
//     }
//     lst_sock.Close();
//     return 0;
// }